package top.infopub.mgr.bpa.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import top.infopub.enums.bpa.BpaProcessDetailTypeEnum;
import top.infopub.enums.mkt.ProProcesssStatusEnum;
import top.infopub.mgr.bpa.dao.BpaProcessDetailDao;
import top.infopub.mgr.bpa.domain.BpaHisProcessDomain;
import top.infopub.mgr.bpa.service.BpaProcessManageService;
import top.infopub.mgr.cap.dao.ContractReviewDao;
import top.infopub.mgr.cap.dao.InformationSubmitApprovalDao;
import top.infopub.mgr.cap.dao.SetupFinDao;
import top.infopub.mgr.common.page.ParamPage;
import top.infopub.mgr.exception.FlowProcessException;
import top.infopub.mgr.flow.cnst.FlowTemplateEnum;
import top.infopub.mgr.flow.service.*;
import top.infopub.mgr.hr.dao.PostGroupDao;
import top.infopub.mgr.mkt.dao.ProjectInfoDao;
import top.infopub.mgr.sys.service.OperatorService;
import top.infopub.model.bpa.BpaProcessDetail;
import top.infopub.model.cap.SetupFin;
import top.infopub.model.flow.Process;
import top.infopub.model.flow.ProcessNode;
import top.infopub.model.flow.Template;
import top.infopub.model.flow.TemplateNode;
import top.infopub.model.hr.PostGroup;
import top.infopub.model.mkt.ProjectInfo;
import top.infopub.model.sys.Operator;
import top.infopub.security.util.SessionUserUtils;
import top.infopub.security.vo.AuthorizationVO;
import top.infopub.tdp.util.BizParaUtil;
import top.infopub.util.IdFactory;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Service
public class BpaProcessManageServiceImpl implements BpaProcessManageService {
    @Autowired
    private BpaProcessDetailDao bpaProcessDetailDao;

    @Lazy
    @Autowired
    private WsFlowProcessService wsFlowProcess;

    @Autowired
    private ProcessService processService;

    @Autowired
    private TemplateService templateService;

    @Autowired
    private TemplateNodeService templateNodeService;

    @Autowired
    private ProcessNodeService processNodeService;

    @Lazy
    @Autowired
    private WsFlowProcessService wsFlowProcessService;

    @Autowired
    private OperatorService operatorService;

    @Autowired
    private ProjectInfoDao projectInfoDao;

    @Autowired
    private SetupFinDao setupFinDao;

    @Lazy
    @Autowired
    private OAFlowService oaFlowService;

    @Autowired
    private ContractReviewDao contractReviewDao;

    @Autowired
    private InformationSubmitApprovalDao informationSubmitApprovalDao;

    @Autowired
    private PostGroupDao postGroupDao;

    @Override
    @Transactional
    public String sendProcess(BpaProcessDetailTypeEnum bpdt, String detailJson, String bizSguid, String proCode, AuthorizationVO vo) {
        ProjectInfo proInfo = projectInfoDao.findByProCode(proCode);
        SetupFin setupFin = setupFinDao.queryByProCode(proCode);
        if (proInfo == null && setupFin == null) {
            throw new FlowProcessException("项目数据不存在~~");
        }
        String proName = null;
        if (proInfo != null && StringUtils.isNotBlank(proInfo.getProName())) proName = proInfo.getProName();
        if (setupFin != null && StringUtils.isNotBlank(setupFin.getProName())) proName = setupFin.getProName();
        String processId = IdFactory.getUUIDUpper();
        //保存当前详细数据json格式
        BpaProcessDetail bpd = new BpaProcessDetail();
        bpd.setBizSguid(bizSguid);
        bpd.setProCode(proCode);
        bpd.setFlowNode(bpdt.getNode());
        bpd.setProcessStatus("1");
        bpd.setDetailJson(detailJson);
        bpd.setAddBy(vo.getId());
        bpd.setAddTime(new Date());
        bpd.setProcessId(processId);
        bpaProcessDetailDao.insert(bpd);
        //待办标题
        StringBuffer oaTitle = new StringBuffer();
        oaTitle.append(proName);
        oaTitle.append("-");
        oaTitle.append(bpdt.getNodeName());
        // 注意 这里根据不同的业务分支判断条件 获得不同enum
        FlowTemplateEnum templateEnum = getByCapProcessNode(bpdt);
        //根据表名更新对应业务表的流程ID和流程状态
        bpaProcessDetailDao.modifyProcessStatusBySguid(templateEnum.getSrcBizTable(), ProProcesssStatusEnum.PRO_STATUS1.getCode(), processId, bizSguid);
        // 处理工作流数据
        wsFlowProcess.launch(templateEnum, bizSguid, processId, oaTitle.toString());
        return processId;
    }

    private FlowTemplateEnum getByCapProcessNode(BpaProcessDetailTypeEnum bpdt) {
        if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE1.getNode())) {
            //对外合同-合同谈判
            return FlowTemplateEnum.BPA_CONTRACT_NEG;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE2.getNode())) {
            //对外合同-合同评审
            return FlowTemplateEnum.BPA_CONTRACT_BPAREVIEW;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE3.getNode())) {
            //对外合同-承继协议
            return FlowTemplateEnum.BPA_CONTRACT_EXT;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE4.getNode())) {
            //对外合同-承继协议-补充协议
            return FlowTemplateEnum.BPA_CONTRACT_EXT_SUP;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE5.getNode())) {
            //对外合同-总包备案合同
            return FlowTemplateEnum.BPA_COT_BACKUP;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE6.getNode())) {
            //对外合同清单
            return FlowTemplateEnum.BPA_CONTRACT_ENTRY;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE7.getNode())) {
            //内部协议评审
            return FlowTemplateEnum.BPA_INNER_AGRT;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE8.getNode())) {
            //内部协议-补充协议
            return FlowTemplateEnum.BPA_INNER_SUPPLE;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE9.getNode())) {
            //分包合同评审
            return FlowTemplateEnum.BPA_SUBPACK_COT;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE10.getNode())) {
            //分包补充协议
            return FlowTemplateEnum.BPA_SUBPACK_SUPPLE;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE11.getNode())) {
            //分包合同清单
            return FlowTemplateEnum.BPA_SUBPACK_ENTRY;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE12.getNode())) {
            //设备合同评审
            return FlowTemplateEnum.BPA_DEVICE_COT;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE13.getNode())) {
            //设备补充协议
            return FlowTemplateEnum.BPA_DEVICE_SUPPLE;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE14.getNode())) {
            //设备合同清单
            return FlowTemplateEnum.BPA_DEVICE_ENTRY;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE15.getNode())) {
            //其他合同评审
            return FlowTemplateEnum.BPA_OTHER_CONTRACTS_REVIEW;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE16.getNode())) {
            //其他补充协议
            return FlowTemplateEnum.BPA_OTHER_CONTRACTS_REPLENISH;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE17.getNode())) {
            //其他合同清单
            return FlowTemplateEnum.BPA_OTHER_CONTRACTS_INVENTORY;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE18.getNode())) {
            //对外确权
            return FlowTemplateEnum.BPA_PRIMARY_SURE_OUT;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE19.getNode())) {
            //对内确权
            return FlowTemplateEnum.BPA_PRIMARY_SURE_INNER;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE20.getNode())) {
            //分包确权
            return FlowTemplateEnum.BPA_PRIMARY_SURE_SUBPKG;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE21.getNode())) {
            //设备确权
            return FlowTemplateEnum.BPA_PRIMARY_SURE_DEVI;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE22.getNode())) {
            //其他确权
            return FlowTemplateEnum.BPA_PRIMARY_SURE_OTHER;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE23.getNode())) {
            //项目预结算
            return FlowTemplateEnum.BPA_PROJECT_BUDGET;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE24.getNode())) {
            //对内结算
//            return FlowTemplateEnum.;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE25.getNode())) {
            //商务策划
            return FlowTemplateEnum.BPA_BIZ_PLAN;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE26.getNode())) {
            //结算策划
            return FlowTemplateEnum.BPA_SETTLE_PLAN;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE27.getNode())) {
            //概算分批
//            return FlowTemplateEnum.;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE28.getNode())) {
            //小微评审
//            return FlowTemplateEnum.;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE29.getNode())) {
            //小微激励兑现
//            return FlowTemplateEnum.;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE30.getNode())) {
            //商务成本支付
            return FlowTemplateEnum.BPA_BUSINESS_PAYMENT;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE31.getNode())) {
            //扣款记录
//            return FlowTemplateEnum.;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE32.getNode())) {
            //年度创效计划
//            return FlowTemplateEnum.;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE33.getNode())) {
            //月度创效计划
//            return FlowTemplateEnum.;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE34.getNode())) {
            //周创效确认
//            return FlowTemplateEnum.;
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE35.getNode())) {
            //创效激励兑现
//            return FlowTemplateEnum.;
        }
        return null;
    }

    @Override
    @Transactional
    public void auditProject(String bizSguid, String processId, String status, String auditMsg) {
        Process proc = processService.selectByPrimaryKey(processId);
        if (proc == null) {
            throw new FlowProcessException("获取不到对应的审批主数据~~");
        }
        BpaProcessDetail bpd = bpaProcessDetailDao.queryByProcessId(processId);
        if (bpd == null) {
            throw new FlowProcessException("发起审批业务数据不存在~~");
        }
        bizSguid = bpd.getBizSguid();
        ProjectInfo proInfo = projectInfoDao.findByProCode(bpd.getProCode());
        SetupFin setupFin = setupFinDao.queryByProCode(bpd.getProCode());
        if (proInfo == null && setupFin == null) {
            throw new FlowProcessException("项目数据不存在~~");
        }
        String proName = null;
        if (proInfo != null && StringUtils.isNotBlank(proInfo.getProName())) proName = proInfo.getProName();
        if (setupFin != null && StringUtils.isNotBlank(setupFin.getProName())) proName = setupFin.getProName();
        // 当前索引
        Integer nowIdx = proc.getNowIdx();
        // 模板ID
        String templateId = proc.getTemplateId();
        // 获得关联业务表名
        String srcBizTable = proc.getSrcBizTable();
        AuthorizationVO vo = SessionUserUtils.getSessionAttributeForUserDtl();
        // 操作人ID
        String userId = vo.getId();
        // 操作人姓名
        String realName = vo.getRealName();
        //待办标题
        StringBuffer oaTitle = new StringBuffer();
        oaTitle.append(proName);
        oaTitle.append("-");
        BpaProcessDetailTypeEnum cpdt = BpaProcessDetailTypeEnum.getByNode(bpd.getFlowNode());
        if (cpdt != null) {
            oaTitle.append(cpdt.getNodeName());
        }

        Template queryTemplate = new Template();
        queryTemplate.setId(templateId);
        queryTemplate.setIsUsable("1");// 可用
        List<Template> templates = templateService.selectByEntityWhere(queryTemplate);
        if (templates == null || templates.size() < 1) {
            throw new FlowProcessException("获取不到对应的工作流模板数据~");
        }
        // 查询当前模板剩余的【审批】节点信息 nodex>nowIdx 按照节点索引正序 (不查询[知会]节点)
        List<TemplateNode> templateNodeList = templateNodeService.queryRestNodes(templateId,nowIdx);
        if (templateNodeList == null) {
            throw new FlowProcessException("获取不到对应的工作流节点数据~");
        }

        // 【重要】特殊处理，融资-立项的 副总有最终审批权， [轮到副总审批时]，移除最后的董事长node，使副总作为最后节点
        TemplateNode capSetupFinLast = new TemplateNode();
        if (srcBizTable.equalsIgnoreCase("CAP_SETUP_FIN")) {
            String triggerNodeIdx = BizParaUtil.get("flow_cap_setup_fin_trigger");
            Integer triggerNodeIdxInt = Integer.valueOf(triggerNodeIdx);
            if (nowIdx.equals(triggerNodeIdxInt)) {
                capSetupFinLast = templateNodeList.get(templateNodeList.size() - 1);
                templateNodeList.remove(templateNodeList.size() - 1);
            }
        }

        ProcessNode nowProcNode = new ProcessNode();
        // 非最后一步审核
        if (templateNodeList.size() > 0) {
            // 查询当前审批流程节点
            ProcessNode procNodeWhere = new ProcessNode();
            procNodeWhere.setProcessId(processId);
            procNodeWhere.setNodeIdx(nowIdx);
            procNodeWhere.setState("-1"); // 未审批
            procNodeWhere.setDealUserId(userId);// 审批人为当前操作人
            List<ProcessNode> queryProcessNodes = processNodeService.selectByEntityWhere(procNodeWhere);
            if (queryProcessNodes == null || queryProcessNodes.size() < 1) {
                throw new FlowProcessException("获取不到有效的审批节点数据~");
            }
            // 处理当前审批节点数据
            nowProcNode = queryProcessNodes.get(0);

            //OA待办处理
            if(StringUtils.isNotEmpty(nowProcNode.getOaId())){
                String oaId = nowProcNode.getOaId();
                boolean finishOA = oaFlowService.finishOA(oaId);
                if(finishOA){
                    nowProcNode.setOaFinish(0);
                }else{
                    throw new FlowProcessException("处理OA待办失败，请联系管理员");
                }
            }

            nowProcNode.setDealName(realName);
            nowProcNode.setDealTime(new Date());
            nowProcNode.setState(status);
            nowProcNode.setDealIdea(auditMsg);
            nowProcNode.setUserOrgId(String.valueOf(SessionUserUtils.getSessionAttribute("bindOrgId")));
            nowProcNode.setUserOrgName(String.valueOf(SessionUserUtils.getSessionAttribute("bindOrgName")));
            nowProcNode.setUserDeptId(String.valueOf(SessionUserUtils.getSessionAttribute("bindDeptId")));
            nowProcNode.setUserDeptName(String.valueOf(SessionUserUtils.getSessionAttribute("bindDeptName")));
            processNodeService.updateByPrimaryKey(nowProcNode);

            //如果是会签，则查询会签是否全部通过
            boolean huiQianFlag = true;
            List<ProcessNode> huiQianProcessNodes = null;
            if(nowProcNode.getNodePolicy() == 3){
                ProcessNode hqNode = new ProcessNode();
                hqNode.setProcessId(processId);
                hqNode.setNodeIdx(nowIdx);
                huiQianProcessNodes = processNodeService.selectByEntityWhere(hqNode);
                for (ProcessNode huiQianProcessNode : huiQianProcessNodes) {
                    if(!"1".equals(huiQianProcessNode.getState())){
                        huiQianFlag = false;
                        break;
                    }
                }
            }

            //审批通过
            if (StringUtils.equals("1", status)) {
                if(huiQianFlag) {
                    //判断下个节点是否为--处理中间的知会节点
                    notifyProcess(templateId, nowIdx, processId, srcBizTable, bizSguid);
                    // 下一步的模板节点
                    TemplateNode nextNode = templateNodeList.get(0);
                    List<TemplateNode> nextTemplateNode = new ArrayList<>();
                    for (TemplateNode node : templateNodeList) {
                        if (nextNode.getNodeIdx() == node.getNodeIdx()) {
                            nextTemplateNode.add(node);
                        }
                    }
                    for (TemplateNode templateNode : nextTemplateNode) {
                        List<String> checkUserIds = wsFlowProcessService.checkUserIds(templateNode.getId(), processId);
                        //String tempCheckUserId = checkUserIds(templateNode.getId());
                        for (String tempCheckUserId : checkUserIds) {
                            //发起OA待办
                            String oaId = oaFlowService.sendOAToDo(oaTitle.toString(), SessionUserUtils.getSessionUserId(), tempCheckUserId, srcBizTable, bizSguid);

                            ProcessNode node_next = new ProcessNode();
                            node_next.setAddTime(new Date());
                            node_next.setProcessId(processId);
                            node_next.setNodeIdx(templateNode.getNodeIdx());
                            node_next.setNodeName(templateNode.getNodeName());
                            node_next.setNodePolicy(templateNode.getNodePolicy());// 权限 审批
                            node_next.setDealUserId(tempCheckUserId);// 处理人取模板中的审核人
                            node_next.setDealName(dealNameOf(tempCheckUserId).getSrealName());// 增加处理人姓名
                            node_next.setState("-1");// 节点的审批状态为初始-待审批
                            node_next.setSrcBizTable(srcBizTable);
                            node_next.setSrcBizSguid(bizSguid);
                            node_next.setOaId(oaId);
                            processNodeService.insert(node_next);
                            // 更新审批流程信息
                            proc.setNowIdx(templateNode.getNodeIdx());
                            proc.setMaxIdx(templateNodeList.get(templateNodeList.size() - 1).getNodeIdx());// 再次更新最大索引
                            processService.updateByPrimaryKey(proc);
                        }
                    }
                }
            } else {
                //审批不通过
                proc.setEndTime(new Date());
                proc.setProcessStatus(ProProcesssStatusEnum.PRO_STATUS10.getCode()); // 10=审批终止
                proc.setIsFeedback("0");
                processService.updateByPrimaryKey(proc);
                // 原业务表审批状态 修改为审批终止
                bpaProcessDetailDao.modifyProcessStatusBySguid(srcBizTable, ProProcesssStatusEnum.PRO_STATUS10.getCode(), null, bizSguid);
                //修改项目流程明细表状态
                bpaProcessDetailDao.modifyProcessStatus(ProProcesssStatusEnum.PRO_STATUS10.getCode(), processId);
                //审批不通过需要撤销所有还未审批的会签节点待办
                if (huiQianProcessNodes != null && huiQianProcessNodes.size() > 0) {
                    for (ProcessNode huiQianProcessNode : huiQianProcessNodes) {
                        if("-1".equals(huiQianProcessNode.getState())){
                            oaFlowService.finishOA(huiQianProcessNode.getOaId());
                        }
                    }
                }
            }
        } else {
            //最后一步审核节点
            // 查询当前审批流程节点
            ProcessNode procNodeWhere = new ProcessNode();
            procNodeWhere.setProcessId(processId);
            procNodeWhere.setNodeIdx(nowIdx);
            procNodeWhere.setState("-1"); // 未审批
            procNodeWhere.setDealUserId(userId);// 审批人为当前操作人
            List<ProcessNode> queryProcessNodes = processNodeService.selectByEntityWhere(procNodeWhere);
            if (queryProcessNodes == null || queryProcessNodes.size() < 1) {
                throw new FlowProcessException("获取不到对应的审批节点数据~");
            }
            // 处理当前审批节点数据
            nowProcNode = queryProcessNodes.get(0);

            //OA待办处理
            if(StringUtils.isNotEmpty(nowProcNode.getOaId())){
                String oaId = nowProcNode.getOaId();
                boolean finishOA = oaFlowService.finishOA(oaId);
                if(finishOA){
                    nowProcNode.setOaFinish(0);
                }else{
//                    throw new FlowProcessException("处理OA待办失败，请联系管理员");
                }
            }

            nowProcNode.setDealName(realName);
            nowProcNode.setDealTime(new Date());
            nowProcNode.setState(status);
            nowProcNode.setDealIdea(auditMsg);
            nowProcNode.setUserOrgId(String.valueOf(SessionUserUtils.getSessionAttribute("bindOrgId")));
            nowProcNode.setUserOrgName(String.valueOf(SessionUserUtils.getSessionAttribute("bindOrgName")));
            nowProcNode.setUserDeptId(String.valueOf(SessionUserUtils.getSessionAttribute("bindDeptId")));
            nowProcNode.setUserDeptName(String.valueOf(SessionUserUtils.getSessionAttribute("bindDeptName")));
            processNodeService.updateByPrimaryKey(nowProcNode);

            //如果是会签，则查询会签是否全部通过
            boolean huiQianFlag = true;
            List<ProcessNode> huiQianProcessNodes = null;
            if(nowProcNode.getNodePolicy() == 3){
                ProcessNode hqNode = new ProcessNode();
                hqNode.setProcessId(processId);
                hqNode.setNodeIdx(nowIdx);
                huiQianProcessNodes = processNodeService.selectByEntityWhere(hqNode);
                for (ProcessNode huiQianProcessNode : huiQianProcessNodes) {
                    if(!"1".equals(huiQianProcessNode.getState())){
                        huiQianFlag = false;
                        break;
                    }
                }
            }

            //审核通过
            if (StringUtils.equals("1", status)) {
                // 更新审批流程信息
                if (huiQianFlag) {
                    proc.setEndTime(new Date());
                    proc.setProcessStatus(ProProcesssStatusEnum.PRO_STATUS9.getCode()); // 9=审批完成
                    proc.setIsFeedback("0");
                    processService.updateByPrimaryKey(proc);
                    // 原业务表审批状态 修改审批状态
                    bpaProcessDetailDao.modifyProcessStatusBySguid(srcBizTable, ProProcesssStatusEnum.PRO_STATUS9.getCode(), null, bizSguid);
                    //修改项目流程明细表状态
                    bpaProcessDetailDao.modifyProcessStatus(ProProcesssStatusEnum.PRO_STATUS9.getCode(), processId);

                    // 所有【审核】节点都通过时， 最后统一生成 后续的【知会】节点
                    List<TemplateNode> toNotifyList = templateNodeService.queryRestNotifyNodes(templateId, nowIdx);
                    for (TemplateNode var : toNotifyList) {
                        List<String> strings = wsFlowProcessService.checkUserIds(var.getId(), processId);
                        for (String string : strings) {
                            ProcessNode node_next = new ProcessNode();
                            node_next.setDealUserId(string);// 处理人取模板中的审核人
                            node_next.setAddTime(new Date());
                            node_next.setProcessId(processId);
                            node_next.setNodeIdx(var.getNodeIdx());
                            node_next.setNodeName(var.getNodeName());
                            node_next.setNodePolicy(2);// 权限 知会
                            node_next.setState("1");// 节点的审批状态为-我已同意
                            node_next.setSrcBizTable(srcBizTable);
                            node_next.setSrcBizSguid(bizSguid);
                            processNodeService.insert(node_next);
                        }
                    }

                    //融资管理-新增下一个业务表数据
                    autoNextBizTableData(bpd, vo, bizSguid, srcBizTable, proName);
                }
            } else {
                proc.setEndTime(new Date());
                proc.setProcessStatus(ProProcesssStatusEnum.PRO_STATUS10.getCode()); // 10=审批终止
                proc.setIsFeedback("0");
                processService.updateByPrimaryKey(proc);
                // 原业务表审批状态 修改为审批终止
                bpaProcessDetailDao.modifyProcessStatusBySguid(srcBizTable, ProProcesssStatusEnum.PRO_STATUS10.getCode(), null, bizSguid);
                //修改项目流程明细表状态
                bpaProcessDetailDao.modifyProcessStatus(ProProcesssStatusEnum.PRO_STATUS10.getCode(), processId);

                //审批不通过需要撤销所有还未审批的会签节点待办
                if (huiQianProcessNodes != null && huiQianProcessNodes.size() > 0) {
                    for (ProcessNode huiQianProcessNode : huiQianProcessNodes) {
                        if("-1".equals(huiQianProcessNode.getState())){
                            oaFlowService.finishOA(huiQianProcessNode.getOaId());
                        }
                    }
                }

                // 【重要】特殊处理，融资-立项的 副总审批拒绝，但是董事长可以继续审批  开始
                if (srcBizTable.equalsIgnoreCase("CAP_SETUP_FIN")) {
                    String triggerNodeIdx = BizParaUtil.get("flow_cap_setup_fin_trigger");
                    if (org.apache.commons.lang.StringUtils.isNotBlank(triggerNodeIdx)) {
                        if (org.apache.commons.lang.StringUtils.equals(nowProcNode.getNodeIdx().toString(), triggerNodeIdx)) {
                            // 董事长模板节点
                            ProcessNode node_next = new ProcessNode();
                            node_next.setAddTime(new Date());
                            node_next.setProcessId(processId);
                            node_next.setNodeIdx(capSetupFinLast.getNodeIdx());
                            node_next.setNodeName(capSetupFinLast.getNodeName());
                            node_next.setNodePolicy(capSetupFinLast.getNodePolicy());// 董事长-权限
                            String tempCheckUserId = wsFlowProcessService.checkUserId(capSetupFinLast.getId());
                            node_next.setDealUserId(tempCheckUserId);// 处理人取模板中的审核人
                            node_next.setDealName(dealNameOf(tempCheckUserId).getSrealName());// 增加处理人姓名
                            node_next.setState("-1");// 节点的审批状态为初始-待审批
                            node_next.setSrcBizTable(srcBizTable);
                            node_next.setSrcBizSguid(bizSguid);
                            processNodeService.insert(node_next);
                            // 更新审批流程信息
                            proc.setNowIdx(capSetupFinLast.getNodeIdx());
                            processService.updateByPrimaryKey(proc);
                        }
                    }
                }// 融资-立项的 副总审批拒绝，但是董事长可以继续审批  结束
            }
        }
    }

    /**
     * 商务管理-审核通过新增下个节点主表数据
     * @param vo
     * @param bizSguid
     */
    public void autoNextBizTableData(BpaProcessDetail bpd, AuthorizationVO vo, String bizSguid, String srcBizTable, String proName) {
        BpaProcessDetailTypeEnum bpdt = BpaProcessDetailTypeEnum.getByNode(bpd.getFlowNode());
        if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE1.getNode())) {
            //对外合同-合同谈判
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE2.getNode())) {
            //对外合同-合同评审
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE3.getNode())) {
            //对外合同-承继协议
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE4.getNode())) {
            //对外合同-承继协议-补充协议
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE5.getNode())) {
            //对外合同-总包备案合同
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE6.getNode())) {
            //对外合同清单
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE7.getNode())) {
            //内部协议评审
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE8.getNode())) {
            //内部协议-补充协议
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE9.getNode())) {
            //分包合同评审
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE10.getNode())) {
            //分包补充协议
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE11.getNode())) {
            //分包合同清单
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE12.getNode())) {
            //设备合同评审
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE13.getNode())) {
            //设备补充协议
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE14.getNode())) {
            //设备合同清单
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE15.getNode())) {
            //其他合同评审
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE16.getNode())) {
            //其他补充协议
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE17.getNode())) {
            //其他合同清单
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE18.getNode())) {
            //对外确权
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE19.getNode())) {
            //对内确权
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE20.getNode())) {
            //分包确权
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE21.getNode())) {
            //设备确权
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE22.getNode())) {
            //其他确权
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE23.getNode())) {
            //项目预结算
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE24.getNode())) {
            //对内结算
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE25.getNode())) {
            //商务策划
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE26.getNode())) {
            //结算策划
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE27.getNode())) {
            //概算分批
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE28.getNode())) {
            //小微评审
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE29.getNode())) {
            //小微激励兑现
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE30.getNode())) {
            //商务成本支付
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE31.getNode())) {
            //扣款记录
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE32.getNode())) {
            //年度创效计划
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE33.getNode())) {
            //月度创效计划
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE34.getNode())) {
            //周创效确认
        } else if (StringUtils.equals(bpdt.getNode(), BpaProcessDetailTypeEnum.PRO_NODE_TYPE35.getNode())) {
            //创效激励兑现
        }
    }

    /**
     * 知会节点处理
     * @param templateId
     * @param thisIdxNo
     * @param processId
     * @param srcBizTable
     * @param srcBizSguid
     * @return
     */
    @Override
    public int notifyProcess(String templateId, Integer thisIdxNo, String processId, String srcBizTable, String srcBizSguid) {
        while (true) {
            //查询下一个节点信息
            int nextNodeIdx = thisIdxNo + 1;
            TemplateNode templateNode = templateNodeService.queryNextIdxsNodes(templateId, nextNodeIdx);
            //如果下个节点为空表示所有节点流程已经走完，返回0
            if (templateNode == null) return 0;
            //如果下个节点不是知会节点返回传入的节点，继续走审批流程
            if (templateNode.getNodePolicy() != 2) return thisIdxNo;
            //知会节点录入默认审核状态为-我已同意
            ProcessNode notify_next = new ProcessNode();
            notify_next.setAddTime(new Date());
            notify_next.setProcessId(processId);
            notify_next.setNodeIdx(templateNode.getNodeIdx());
            notify_next.setNodeName(templateNode.getNodeName());
            notify_next.setNodePolicy(2);// 权限 知会
            notify_next.setDealUserId(wsFlowProcessService.checkUserId(templateNode.getId()));// 处理人取模板中的审核人
            notify_next.setState("1");// 节点的审批状态为-我已同意
            notify_next.setSrcBizTable(srcBizTable);
            notify_next.setSrcBizSguid(srcBizSguid);
            processNodeService.insert(notify_next);
            //记录当前节点
            thisIdxNo = nextNodeIdx;
        }
    }

    /**
     * 查询对应的处理人真实姓名
     */
    private Operator dealNameOf(String checkUserId) {
        Operator opt = operatorService.selectByPrimaryKey(checkUserId);
        if (opt == null) {
            return new Operator();
        }
        else {
            return opt;
        }
    }

    @Override
    public String checkShowAuditTab(String processId, AuthorizationVO vo) {
        Process proc = processService.selectByPrimaryKey(processId);
        if (proc == null) {
            return "0";
        }
        // 当前索引
        Integer nowIdx = proc.getNowIdx();
        // 查询当前审批流程节点
        ProcessNode procNodeWhere = new ProcessNode();
        procNodeWhere.setProcessId(processId);
        procNodeWhere.setNodeIdx(nowIdx);
        procNodeWhere.setState("-1"); // 未审批
        procNodeWhere.setDealUserId(vo.getId());// 审批人为当前操作人
        List<ProcessNode> queryProcessNodes = processNodeService.selectByEntityWhere(procNodeWhere);
        if (queryProcessNodes == null || queryProcessNodes.size() < 1) {
            return "0";
        }
        return "1";
    }

    @Override
    public String getProCodeById(String tableName, String id) {
        return bpaProcessDetailDao.queryProCodeById(tableName, id);
    }

    @Override
    public BpaProcessDetail queryByProcessId(String processId) {
        return bpaProcessDetailDao.queryByProcessId(processId);
    }

    @Override
    public List<String> queryFinanceUserIdByProcessId(String processId, String state, String groupId) {
        PostGroup postGroup = postGroupDao.selectByPrimaryKey(groupId);
        if (postGroup == null) return null;
        if (StringUtils.equals("2", postGroup.getRoleType())) {
            //固定人员查询sql
            return bpaProcessDetailDao.queryFinUserIdByProcIdRoleType2(processId, state, groupId);
        } else {
            return bpaProcessDetailDao.queryFinanceUserIdByProcessId(processId, state, groupId);
        }
    }

    @Override
    public void modifyOaIdById(String tableName, String oaId, String id) {
        bpaProcessDetailDao.modifyOaIdById(tableName, oaId, id);
    }

    @Override
    public PageInfo<BpaHisProcessDomain> getHisProcessPage(String proCode, ParamPage paramPage) {
        PageHelper.startPage(paramPage.getPage(), paramPage.getLimit());
        List<BpaHisProcessDomain> list = bpaProcessDetailDao.queryHisProcessList(proCode);
        PageInfo<BpaHisProcessDomain> pageInfo = new PageInfo<BpaHisProcessDomain>(list);
        return pageInfo;
    }

    @Override
    public void modifyDetailJsonById(BpaProcessDetail cpd) {
        bpaProcessDetailDao.modifyDetailJsonById(cpd);
    }
}
